/**
 * 给定K和C，以及一个N节点的树，初始树根是1
 * 可以将树根移动到任意节点，其花费是 C*移动的距离
 * 定好树根后，其收益是 K * 最远子孙的距离
 * 利润是 收益 - 花费
 * 问最大利润是多少
 * 
 * 首先固定1为树根，令Ui和Vi分别是最远与次远距离，且Li是i的最远子孙，一遍dfs即可
 * 再令 Fi 是经过i的父亲到达i的最远距离，则
 * Fi = 1 + max(Fp, Up或者Vp) 其中p是i的父亲
 * 于是可以求出距离i节点最远的距离，计算利润即可，花费可以直接用参数传
 */
#include <bits/stdc++.h>
using namespace std;

using llt = long long;

int N, K, C;
vector<vector<int>> G;

vector<int> L, U, V;

void dfs(int u, int p){
    U[u] = V[u] = L[u] = 0;
    for(auto v : G[u]){
        if(v == p) continue;
        dfs(v, u);
        if(U[u] < U[v] + 1){
            V[u] = U[u];
            U[u] = U[v] + 1;
            L[u] = v;
        }else if(V[u] < U[v] + 1){
            V[u] = U[v] + 1;
        }
    }
    return;
}

vector<int> F;
llt Ans;

void recurse(int u, int p, llt cost){
    if(p){
        if(u == L[p]){
            F[u] = 1 + max(F[p], V[p]);
        }else{
            F[u] = 1 + max(F[p], U[p]);
        }
    }

    llt tmp = max(F[u], U[u]);
    tmp *= K;
    tmp -= cost;

    Ans = max(Ans, tmp);

    for(auto v : G[u]){
        if(v == p) continue;
        recurse(v, u, cost + C);
    }
    return;
}

llt proc(){
    L.assign(N + 1, 0);
    U.assign(N + 1, 0);
    V.assign(N + 1, 0);

    dfs(1, 0);

    F.assign(N + 1, 0);
    Ans = 0LL;
    recurse(1, 0, 0);
    return Ans;
}

int main(){
#ifndef ONLINE_JUDGE
    freopen("z.txt", "r", stdin);
#endif
    ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
    int nofkase; cin >> nofkase;
    while(nofkase--){
        cin >> N >> K >> C;
        G.assign(N + 1, {});
        for(int a,b,i=1;i<N;++i){
            cin >> a >> b;
            G[a].push_back(b);
            G[b].push_back(a);
        }
        cout << proc() << endl;
    }
    return 0;
}